import User from "../../api/modules/User";
import Toast from "../../utils/Toast";
import {isEmpty, isTrue} from "../../utils/helpers";
import Config from "../../config/Config";
import {useStore} from "vuex";
import {useRouter} from "vue-router";
import store from "../../store"
import router from "../../router"
import avatarImage from "../../assets/img/cover.png";
import Member from "../../api/modules/Member";
import Teacher from "../../api/modules/Teacher";

const StoreUserIdKey = 'ms_username_id'; // 当前登录id存贮的key
const StoreUserNameKey = 'ms_username';// 当前登录用户名存贮的key
const StoreUserAvatarKey = 'ms_avatar';// 当前登录用户头像存贮的key
const StoreIsAdminKey = 'is_admin'; // 当前登录用户是否是管理员存贮的key
const StoreRoleKey = 'user_role'; // 当前用户角色key
const Storage = sessionStorage; // 用户登录信息使用的storage类型

export const TeacherLevels = { // 角色类型
    common: '教师',
    middle: '中级教师',
    high: '高级教师',
    super: '特级教师',
}

export const RoleTypes = { // 角色类型
    admin: 'admin',
    teacher: 'teacher',
    student: 'student',
}

// 获取登录的token
export function getToken() {
    return Storage.getItem(Config.loginTokenKey)
}

/**
 * 清除登录信息
 * @param {boolean} isReplace 是否需要替换路由 true:清除后会自动调整到登录页面
 */
export function removeUserInfo(isReplace = true) {
    Storage.clear();
    store.commit("user/isAdmin", false)
    store.commit("user/setRole", null)
    store.commit("user/setToken", null)
    store.commit("user/setUserInfo", {})
    if (isReplace) {
        router.replace({name: Config.loginRouteName})
    }
}

// 用户登录相关的处理函数集合
export function useUserLogin() {
    // vuex的实例获取（可以操作src/store/目录下的数据）
    const store = useStore(); // 获取vuex对象
    // 路由实例的获取（路由跳转操作使用）
    const router = useRouter(); // 获取router对象

    /**
     * 初始化登录信息
     * 具体的功能：
     * 1、从sessionStorage从读取登录用户信息 (硬盘中)
     * 2、将信息保存到vuex store中 （内存中）方便后续操作
     * 使用地点：
     * 1、可通过全局搜索 .initUserInfo2Vuex( 找到使用的位置
     * 2、src/layout/Home.vue 控制台模板框架组件，如果未登录会自动跳转到登录页面
     * 3、src/App.vue 公共的是初始化（用于登录用户信息的刷新，但不验证token）
     * @param {boolean} checkToken 是否验证token true：验证token，如果没有登录则会自动跳转登录页面，控制台中未登录用户会自动跳转
     */
    async function initUserInfo2Vuex(checkToken = true) {
        const info = await getUserInfo(checkToken, true); // 从硬盘中获取登录后存贮的用户信息
        store.commit("user/setRole", info.role); // 设置是否管理员状态到内存中(vuex)
        store.commit("user/isAdmin", info.isAdmin); // 设置是否管理员状态到内存中(vuex)
        store.commit("user/setToken", info.token); // 设置用户token到内存中(vuex)

        if (isEmpty(info.avatar)) { // 头像不存在时 设置默认头像
            info.avatar = avatarImage;
        }
        store.commit("user/setUserInfo", info || {}); // 设置用户信息到内存中(vuex)
        return info;
    }


    /**
     * 将用户信息保存到sessionStorage中
     * @param data
     * @param role {string} 角色
     * @param isInit {boolean} 是否重新初始化vuex内存中的数据
     */
    function saveUserInfo(data = {}, role, isInit = true) {
        Storage.setItem(StoreUserIdKey, data.id);
        Storage.setItem(StoreUserNameKey, data.name || data.username || data.phone);
        Storage.setItem(StoreUserAvatarKey, data.headImg || data.avatar);
        Storage.setItem(StoreIsAdminKey, `${role === RoleTypes.admin}`);
        Storage.setItem(StoreRoleKey, role);
        Storage.setItem(Config.loginTokenKey, data.phone);
        if (isInit) {
            initUserInfo2Vuex(false);
        }
    }

    /**
     * 从sessionStorage中获取用户信息
     * @param checkToken {boolean} true:验证用户登录状态，移除则清除，跳转登录页面
     * @param refresh {boolean} true:重新请求用户信息
     * @returns {{id: string, avatar: string, isAdmin: (*|boolean), username: string, token: string}}
     */
    async function getUserInfo(checkToken = true, refresh = false) {
        const info = {
            id: Storage.getItem(StoreUserIdKey),
            username: Storage.getItem(StoreUserNameKey),
            avatar: Storage.getItem(StoreUserAvatarKey),
            role: Storage.getItem(StoreRoleKey),
            isAdmin: isTrue(Storage.getItem(StoreIsAdminKey)),
            token: Storage.getItem(Config.loginTokenKey),
        }
        if (checkToken && isEmpty(info.token)) { // 用户信息异常
            removeUserInfo();
        } else if (refresh && !isEmpty(info.id)) { // 刷新用户信息
            try {
                try {
                    let data = {}
                    if (info.role === RoleTypes.teacher) {
                        const res = await Teacher.info(info.id);
                        data = res.data || {}
                    } else {
                        const res = await Member.info(info.id);
                        data = res.data || {}
                    }
                    // 新的数据
                    const newInfo = {
                        ...info,
                        ...(data || {}),
                        avatar: data.headImg,
                        username: data.name,
                    }
                    saveUserInfo(newInfo, newInfo.role, false)
                    return newInfo;
                } catch (e) {

                }
            } catch (e) {

            }
        }
        return info;
    }

    /**
     * 用户登录
     * @param username 账号、手机号
     * @param password 密码
     * @param role 角色
     * @param replace 角色
     * @returns {Promise<boolean>}
     */
    async function login(username, password, role = RoleTypes.student, replace = true) {
        try {
            if (isEmpty(username) || isEmpty(password)) {
                throw new Error("用户名或密码错误")
            }
            switch (role) {
                case RoleTypes.admin: // 管理员登录
                    let aRes = await User.adminLogin(username, password);
                    Toast.success(aRes.message)
                    saveUserInfo({
                        phone: username,
                        avatar: null,
                    }, role)
                    break;
                case RoleTypes.teacher: // 教师登录
                    const tRes = await User.teacherLogin(username, password);
                    Toast.success(tRes.message);
                    saveUserInfo(tRes.data, role)
                    break;
                case RoleTypes.student: // 学生的登录
                    const {message, data} = await User.login(username, password);
                    Toast.success(message);
                    saveUserInfo(data, role)
                    break;
                default:
                    Toast.error('暂无支持该类型的角色登录');
                    return false;
            }

            if (replace) { // 如果是管理员登录成功则直接跳转到控制台
                await router.replace({name: Config.homeRouteName})
            }
            return true;
        } catch (e) {
            Toast.warning(e.message)
        }
        return false;
    }

    /**
     * 退出登录
     * @param isReplace {boolean} 退出后是否跳转登录页面
     * @returns {Promise<void>}
     */
    async function logout(isReplace = true) {
        try {
            // const res = await User.logout();
            removeUserInfo(isReplace);
        } catch (e) {
            Toast.warning(e.message);
            removeUserInfo(isReplace);
        }
    }

    // 返回集合方法
    return {
        login,
        logout,
        getUserInfo,
        initUserInfo2Vuex,
        removeUserInfo,
    }

}
